Published on

How I Stopped Resisting AI and Started Teaching It

Authors
  • avatar
    Name
    Omar Elsayed
    Twitter

A year ago, if you told me I'd be contributing to AI tooling, I would have laughed. Today, I'm co-authoring open source agent skill for SwiftUI alongside Antoine van der Lee, and honestly? It feels like a dream 😅.

This isn't a story about jumping on the AI bandwagon. This is about going from actively limiting AI's role in my workflow to building tools that help other developers leverage it effectively. It's about confronting my fears head-on and discovering something unexpected on the other side.

Remember when everyone said AI would replace engineers? When LinkedIn was flooded with hot takes about the end of software development as we knew it? I wasn't just skeptical of the hype—I was genuinely worried about what relying on AI would do to me as an engineer. Would it make me lazy? Would I lose my edge? Would I become dependent on a tool I didn't fully understand?

Fast forward today, I contributed to open-source AI agent skill for SwiftUI. Not because I drank the Kool-Aid, but because I discovered something that changed everything: the difference between being replaced by AI and teaching AI to think like you.

This is the story of that transformation.

The Resistance Phase: Why I Pushed Back

When ChatGPT exploded onto the scene and everyone started talking about AI-assisted development, my first instinct wasn't excitement, it was worry.

The narrative everywhere was the same: "AI will replace software engineers." LinkedIn was flooded with posts about it. Tech Twitter was having a meltdown.

Everyone had an opinion about whether engineers would still have jobs in five years, even Claude CEO, Dario Amode, claimed that AI would make developers obsolete by 2026. Guess who is laughing now 🤣.

But my concern wasn't really about job security. It was something deeper.

Here's what kept me up at night: What if relying on AI made me a worse engineer?

Think about it. When you use autocomplete constantly, do you remember phone numbers anymore? When GPS handles navigation, can you still read a map? When calculators do the math, do you know how to calculate it yourself anymore?

I was genuinely worried that AI would become a crutch. That I'd stop understanding the fundamentals. That I'd become dependent on a tool that could spit out code I didn't fully comprehend.

// The typical AI interaction that frustrated me:
// Me: "Create a SwiftUI view with animations"
// AI: *generates 200 lines of code*
// Me: "Wait, why did you use GeometryReader here?"
// AI: *generates different code with different patterns*
// Me: "This doesn't follow best practices..."
// AI: *tries again with yet another approach*

The problem wasn't that AI couldn't write code. It was that AI didn't write code the way I would write it. It didn't follow best practices. It didn't follow team's conventions. And worst of all? I spent more time correcting the AI's work than I would have spent just writing the feature myself.

So I limited my AI use. Kept it at arm's length. Used it occasionally for boilerplate, but never for anything serious.

And to be honest, I love the feeling of writing code and solving problems, I didn't want anything to take this from me, if AI is going to take this from me at least do it right not spending time correcting AI's code.

The Turning Point: Discovering Agent Skills

Everything changed when I stumbled upon the concept of agent skills.

One morning, I was doing my usual email sweep—checking what's new in the iOS world—when I stumbled across Antoine van der Lee's latest newsletter. He had a video about something called Agent Skills.

I'll be honest: I clicked it with low expectations. Just another AI thing, right?

Wrong. So wrong.

Agent Skills were completely different from the "AI code generator" tools I'd been avoiding. Instead of vague prompts like "write me some code," you could give AI detailed, step-by-step instructions about how to approach problems in your specific domain. It was like creating a playbook that AI could actually follow—consistently.

The lightbulb moment hit me like a truck: What if instead of fighting against AI's tendency to generate inconsistent code, I could teach it exactly how I wanted things done? with agent skills.

Agent skills flipped the entire equation:

Before: Spend 30 minutes correcting AI-generated code to match my standards.

After: Spend 30 minutes once writing a skill that teaches the AI my standards, then never correct that pattern again.

It was like the difference between explaining to someone every single day how you like your coffee and writing down your coffee order once and having them remember it forever.

(Fun fact: I quit coffee years ago, but my brain apparently hasn't updated its analogy database yet. Classic developer move—deprecated but still in production. 😂)

# Before: Vague prompting
"Create a SwiftUI view with proper architecture"
→ Gets random architecture patterns

# After: Agent skill
"Use swiftui-expert-skill to create a view"
→ Gets consistent, production-ready code following specific patterns

The realization was profound: I wasn't degrading my skills by using AI, I was encoding my skills into a reusable format that could scale across projects.

And this fact was empowering, I could now focus on creating new skills and improving existing ones, knowing that my knowledge was being preserved and shared.

Teaching AI to Think Like a SwiftUI Expert

So I did what any curious developer would do: I went snooping. That's when I found that Antoine had already created swift-concurrency-agent-skill—a skill specifically for teaching AI about Swift's modern concurrency patterns.

I read through the whole thing. Studied how he structured it. Saw the patterns he encoded. And I couldn't stop thinking: this same approach would be perfect for SwiftUI.

Because let's be real—AI generates SwiftUI code like it's still 2021. Deprecated APIs, outdated patterns, missing all the cool stuff Apple keeps shipping. Someone needed to fix this.

I shot Antoine a text: "What about creating SwiftUI agent skill together me and you. With the knowledge you have and what I have we can create one that is very good"

He replied almost immediately: "I’m down!"

That's how swiftui-expert-skill started.

At first, we kept our ambitions reasonable: create a skill covering SwiftUI best practices—proper state management, view architecture, the fundamentals. Ship it and help some people. Done.

But here's the thing about working with someone who gets it: scope creep becomes scope evolution.

As we started building, we kept asking ourselves: "Why stop there?" Best practices are great, but what about the latest APIs? What about the patterns we've learned from building real apps? What about all those edge cases and gotchas that only come from production experience?

We expanded everything.

The skill wouldn't just teach best practices—it would keep AI current with modern SwiftUI development. latest APIs, emerging patterns, real-world solutions.

Not the SwiftUI of yesterday, but the SwiftUI we write today.

Breaking Down What's Inside

swiftui-expert-skill is structured around the three areas where AI consistently screws up SwiftUI code, we didn't try to teach it everything—we focused on what actually breaks in production.

1. Making Smart SwiftUI Decisions

AI loves throwing random property wrappers at the wall to see what sticks. We taught it to think instead:

  • Pick the right state management tool—@State, @Binding, @Observable, @Bindable—each has a specific job, and using the wrong one isn't just bad style, it literally breaks functionality
  • Suggest modern replacements for deprecated APIs—because nobody should be writing NavigationView in 2025
  • Navigate sheets, navigation, scrolling, and lists correctly—the stuff that makes up 80% of every iOS app
  • Handle iOS 26+ Liquid Glass properly with fallbacks—use cutting-edge APIs

2. Writing Views That Don't Suck

This is where vanilla AI falls flat on its face. We fixed it:

  • Keep view identity stable—no more ForEach mistakes that cause mysterious list bugs and state loss
  • Compose views properly—break things down so a human can actually read and maintain your code
  • Avoid the re-render trap—stop triggering unnecessary view updates that make your UI feel sluggish

3. Actually Caring About Performance

SwiftUI makes it dangerously easy to write code that works but runs like garbage:

  • Cut out redundant state updates—every wasted render drains battery and frustrates users
  • Optimize list performance—stable IDs and consistent structure make scrolling feel native
  • Downsample images intelligently—optional, but can save you from embarrassing memory crashes

Why This Skill Hits Different

We made some deliberate choices that set this apart from other AI code generation attempts:

We're Not Opinionated (Where It Doesn't Matter)
The skill focuses on correctness and modern APIs—not forcing some specific architecture or code style down your throat.

MVVM, TCA, VIPER, whatever—we don't care, we just make sure your SwiftUI code is solid regardless of how you structure your app.

Use your team's patterns. We'll make sure the SwiftUI part works.

We're Aggressively Modern
The skill actively hunts down deprecated APIs and replaces them with current best practices, it knows NavigationView is legacy.

It knows iOS 18 shipped better patterns for common tasks, AI won't accidentally generate outdated code because we keep the knowledge base current.

When Apple ships new APIs, we update the skill.

We Respect Intelligence
We wrote this assuming the AI agent isn't stupid—it just needs context, No lengthy explanations, No treating it like a beginner.

Just practical checklists, common pitfalls, and the gotchas that every SwiftUI developer learns the hard way.

It's like having a senior dev pair programming with AI—quick feedback, actionable advice, no fluff.

// Skill Structure

swiftui-expert-skill/
  SKILL.md
  references/
    image-optimization.md - AsyncImage usage, downsampling, caching
    layout-best-practices.md - Layout patterns and GeometryReader alternatives
    liquid-glass.md - iOS 26+ glass effects and fallback patterns
    list-patterns.md - ForEach identity and list performance
    modern-apis.md - Deprecated API replacements
    performance-patterns.md - Hot-path optimizations and update control
    scroll-patterns.md - ScrollViewReader and programmatic scrolling
    sheet-navigation-patterns.md - Sheets and type-safe navigation
    state-management.md - Property wrapper selection and data flow
    text-formatting.md - Modern Text formatting and string utilities
    view-structure.md - View extraction and composition patterns

The difference is night and day, When an AI agent uses swiftui-expert-skill it generates code that:

  • Follows Swift 6 concurrency best practices
  • Uses modern SwiftUI patterns (not deprecated APIs)
  • Implements proper error handling
  • Considers accessibility from the start
  • Matches production code quality standards

It's like having a senior SwiftUI engineer reviewing every piece of AI-generated code before it reaches you.

Conclusion: Partnership, Not Replacement

Here's what I learned from this journey, AI isn't replacing engineers it's amplifying the engineers who know how to teach it.

The fear I had about skill degradation was backwards, Creating agent skills made me a better engineer because:

  1. I had to articulate my knowledge clearly - Writing skills forced me to think deeply about why I do things certain ways
  2. I stayed current with best practices - Maintaining skills meant staying on top of SwiftUI updates
  3. I learned from others - Collaborating with Twan exposed me to patterns I hadn't considered
  4. I scaled my impact - My knowledge could now help thousands of developers through the skill

The engineers who will thrive in the AI era aren't the ones who reject it or blindly accept it.

They're the ones who shape it, teach it, and contribute to making it better.

So if you're still on the fence about AI, I get it, I was there too.

But consider this: What if instead of worrying about AI replacing you, you focused on teaching AI to think like you?

Your expertise is valuable. Your patterns matter. Your standards are worth encoding.

And the beautiful part? Once you encode them, they become a gift to the entire community.

Check out swiftui-expert-skill and let me know what you think. Better yet, contribute and help make AI-agent generates even better SwiftUI code.

The future isn't human vs. AI. It's human + AI, working together to build better software.

And honestly? That's a future I'm excited to be part of.

Subscribe for more like this

Subscribe for more